The Polyhedral Model Beyond Loops Recursion Optimization and Parallelization Through Polyhedral Modeling

International audienceThere may be a huge gap between the statements outlined by programmers in a program source code and instructions that are actually performed by a given processor architecture when running the executable code. This gap is due to the way the input code has been interpreted, translated and transformed by the compiler and the final processor hardware. Thus, there is an opportunity for efficient optimization strategies, that are dedicated to specific control structures and memory access patterns, to apply as soon as the actual runtime behavior has been discovered, even if they could not have been applied on the original source code. In this paper, we develop this idea by identifying code extracts that behave as polyhedral-compliant loops at runtime, while not having been outlined at all as loops in the original source code. In particular, we are interested in recursive functions whose runtime behavior can be modeled as polyhedral loops. Therefore, the scope of this study exclusively includes recursive functions whose control flow and memory accesses exhibit an affine behavior, which means that there exists a semantically equivalent affine loop nest, candidate for poly-hedral optimizations. Accordingly, our approach is based on analyzing early executions of a recursive program using a Nested Loop Recognition (NLR) algorithm, performing the affine loop modeling of the original program runtime behavior , which is then used to generate an equivalent iterative program, finally optimized using the polyhedral compiler Polly. We present some preliminary results showing that this approach brings recursion optimization techniques into a higher level in addition to widening the scope of the polyhe-dral model to include originally non-loop programs

Rec2Poly: Converting Recursions to Polyhedral Optimized Loops Using an Inspector-Executor Strategy

International audienceIn this paper, we propose Rec2Poly, a framework which detects automatically if recursive programs may be transformed into affine loops that are compliant with the polyhedral model. If successful, the replacing loops can then take advantage of advanced loop optimizing and parallelizing transformations as tiling or skewing. Rec2Poly is made of two main phases: an offline profiling phase and an inspector-executor phase. In the profiling phase, the original recursive program, which has been instrumented, is run. Whenever possible, the trace of collected information is used to build equivalent affine loops from the runtime behavior. Then, an inspector-executor program is automatically generated, where the inspector is made of a light version of the original recursive program, whose aim is reduced to the generation and verification of the information which is essential to ensure the correctness of the equivalent affine loop program. The collected information is mainly related to the touched memory addresses and the control flow of the so-called "impacting" basic blocks of instructions. Moreover, in order to exhibit the lowest possible time-overhead, the inspector is implemented as a parallel process where several memory buffers of information are verified simultaneously. Finally, the executor is made of the equivalent affine loops that have been optimized and parallelized

Facilitating the Implementation of Distributed Systems with Heterogeneous Interactions

International audienceWe introduce HDBIP an extension of the Behavior Interaction Priority (BIP) framework. BIP is a component-based framework with a rigorous operational semantics and high-level and expressive interaction model. HDBIP extends BIP interaction model by allowing heterogeneous interactions targeting distributed systems. HDBIP allows both multiparty and direct send/receive interactions that can be directly mapped to an underlying communication library. Then, we present a correct and efficient code generation from HDBIP to C++ implementation using Message Passing Interface (MPI). We present a non-trivial case study showing the effectiveness of HDBIP

Réécriture spéculative de programmes récursifs en boucles candidates à une parallélisation et une optimisation efficaces utilisant un mécanisme inspecteur-exécuteur

In this thesis, we introduce Rec2Poly, a framework for speculative rewriting of recursiveprograms as affine loops that are candidates for efficient optimization and paralleliza-tion. Rec2Poly seeks a polyhedral-compliant run-time control and memory behavior inrecursions making use of an offline profiling technique. When it succeeds to model thebehavior of a recursive program as affine loops, it can use the affine loop model to automatically generate an optimized and parallelized code based on the inspector-executorstrategy for the next executions of the program. The inspector involves a light version ofthe original recursive program whose role is to collect, generate and verify run-time in-formation that is crucial to ensure the correctness of the equivalent affine iterative code.The executor is composed of the affine loops that can be parallelized or even optimizedusing the polyhedral model.Dans cette thèse, nous proposons Rec2Poly, un cadriciel pour la réécriture spéculativedes programmes récursifs sous forme de boucles affines qui sont candidates à une parallélisation et une optimisation efficaces. Rec2Poly cherche un flot de contrôle dyna-mique et un comportement mémoire conformes au modèle polyédrique dans les récursions, en utilisant une technique de profilage hors ligne. Lorsqu’il réussit à modéliser lecomportement d’un programme récursif sous forme de boucles affines, il peut utiliser lemodèle de boucle affine pour générer automatiquement un code optimisé et parallélisébasé sur la stratégie inspecteur-exécuteur pour les prochaines exécutions du programme.L’inspecteur implique une version allégée du programme récursif d’origine dont le rôle estde collecter, générer et vérifier les informations d’exécution qui sont essentielles pour garantir l’exactitude du code itératif affine équivalent. L’exécuteur est composé des bouclesaffines qui peuvent être parallélisées voire optimisées à l’aide du modèle polyédrique

Réécriture spéculative de srogrammes récursifs en boucles candidates à une parallélisation et une optimisation efficaces utilisant un mécanisme inspecteur-exécuteur.

Dans cette thèse, nous proposons Rec2Poly, un cadriciel pour la réécriture spéculative des programmes récursifs sous forme de boucles affines qui sont candidates à une parallélisation et une optimisation efficaces. Rec2Poly cherche un flot de contrôle dynamique et un comportement mémoire conformes au modèle polyédrique dans les récursions, en utilisant une technique de profilage hors ligne. Lorsqu’il réussit à modéliser le comportement d’un programme récursif sous forme de boucles affines, il peut utiliser le modèle de boucle affine pour générer automatiquement un code optimisé et parallélisé basé sur la stratégie inspecteur-exécuteur pour les prochaines exécutions du programme. L’inspecteur implique une version allégée du programme récursif d’origine dont le rôle est de collecter, générer et vérifier les informations d’exécution qui sont essentielles pour garantir l’exactitude du code itératif affine équivalent. L’exécuteur est composé des boucles affines qui peuvent être parallélisées voire optimisées à l’aide du modèle polyédrique.In this thesis, we introduce Rec2Poly, a framework for speculative rewriting of recursive programs as affine loops that are candidates for efficient optimization and parallelization. Rec2Poly seeks a polyhedral-compliant run-time control and memory behavior in recursions making use of an offline profiling technique. When it succeeds to model the behavior of a recursive program as affine loops, it can use the affine loop model to automatically generate an optimized and parallelized code based on the inspector-executor strategy for the next executions of the program. The inspector involves a light version of the original recursive program whose role is to collect, generate and verify run-time information that is crucial to ensure the correctness of the equivalent affine iterative code. The executor is composed of the affine loops that can be parallelized or even optimized using the polyhedral model

Réécriture spéculative de srogrammes récursifs en boucles candidates à une parallélisation et une optimisation efficaces utilisant un mécanisme inspecteur-exécuteur.

In this thesis, we introduce Rec2Poly, a framework for speculative rewriting of recursive programs as affine loops that are candidates for efficient optimization and parallelization. Rec2Poly seeks a polyhedral-compliant run-time control and memory behavior in recursions making use of an offline profiling technique. When it succeeds to model the behavior of a recursive program as affine loops, it can use the affine loop model to automatically generate an optimized and parallelized code based on the inspector-executor strategy for the next executions of the program. The inspector involves a light version of the original recursive program whose role is to collect, generate and verify run-time information that is crucial to ensure the correctness of the equivalent affine iterative code. The executor is composed of the affine loops that can be parallelized or even optimized using the polyhedral model.Dans cette thèse, nous proposons Rec2Poly, un cadriciel pour la réécriture spéculative des programmes récursifs sous forme de boucles affines qui sont candidates à une parallélisation et une optimisation efficaces. Rec2Poly cherche un flot de contrôle dynamique et un comportement mémoire conformes au modèle polyédrique dans les récursions, en utilisant une technique de profilage hors ligne. Lorsqu’il réussit à modéliser le comportement d’un programme récursif sous forme de boucles affines, il peut utiliser le modèle de boucle affine pour générer automatiquement un code optimisé et parallélisé basé sur la stratégie inspecteur-exécuteur pour les prochaines exécutions du programme. L’inspecteur implique une version allégée du programme récursif d’origine dont le rôle est de collecter, générer et vérifier les informations d’exécution qui sont essentielles pour garantir l’exactitude du code itératif affine équivalent. L’exécuteur est composé des boucles affines qui peuvent être parallélisées voire optimisées à l’aide du modèle polyédrique

Réécriture spéculative de srogrammes récursifs en boucles candidates à une parallélisation et une optimisation efficaces utilisant un mécanisme inspecteur-exécuteur.

In this thesis, we introduce Rec2Poly, a framework for speculative rewriting of recursive programs as affine loops that are candidates for efficient optimization and parallelization. Rec2Poly seeks a polyhedral-compliant run-time control and memory behavior in recursions making use of an offline profiling technique. When it succeeds to model the behavior of a recursive program as affine loops, it can use the affine loop model to automatically generate an optimized and parallelized code based on the inspector-executor strategy for the next executions of the program. The inspector involves a light version of the original recursive program whose role is to collect, generate and verify run-time information that is crucial to ensure the correctness of the equivalent affine iterative code. The executor is composed of the affine loops that can be parallelized or even optimized using the polyhedral model.Dans cette thèse, nous proposons Rec2Poly, un cadriciel pour la réécriture spéculative des programmes récursifs sous forme de boucles affines qui sont candidates à une parallélisation et une optimisation efficaces. Rec2Poly cherche un flot de contrôle dynamique et un comportement mémoire conformes au modèle polyédrique dans les récursions, en utilisant une technique de profilage hors ligne. Lorsqu’il réussit à modéliser le comportement d’un programme récursif sous forme de boucles affines, il peut utiliser le modèle de boucle affine pour générer automatiquement un code optimisé et parallélisé basé sur la stratégie inspecteur-exécuteur pour les prochaines exécutions du programme. L’inspecteur implique une version allégée du programme récursif d’origine dont le rôle est de collecter, générer et vérifier les informations d’exécution qui sont essentielles pour garantir l’exactitude du code itératif affine équivalent. L’exécuteur est composé des boucles affines qui peuvent être parallélisées voire optimisées à l’aide du modèle polyédrique

Réécriture spéculative de programmes récursifs en boucles candidates à une parallélisation et une optimisation efficaces utilisant un mécanisme inspecteur-exécuteur

In this thesis, we introduce Rec2Poly, a framework for speculative rewriting of recursiveprograms as affine loops that are candidates for efficient optimization and paralleliza-tion. Rec2Poly seeks a polyhedral-compliant run-time control and memory behavior inrecursions making use of an offline profiling technique. When it succeeds to model thebehavior of a recursive program as affine loops, it can use the affine loop model to automatically generate an optimized and parallelized code based on the inspector-executorstrategy for the next executions of the program. The inspector involves a light version ofthe original recursive program whose role is to collect, generate and verify run-time in-formation that is crucial to ensure the correctness of the equivalent affine iterative code.The executor is composed of the affine loops that can be parallelized or even optimizedusing the polyhedral model.Dans cette thèse, nous proposons Rec2Poly, un cadriciel pour la réécriture spéculativedes programmes récursifs sous forme de boucles affines qui sont candidates à une parallélisation et une optimisation efficaces. Rec2Poly cherche un flot de contrôle dyna-mique et un comportement mémoire conformes au modèle polyédrique dans les récursions, en utilisant une technique de profilage hors ligne. Lorsqu’il réussit à modéliser lecomportement d’un programme récursif sous forme de boucles affines, il peut utiliser lemodèle de boucle affine pour générer automatiquement un code optimisé et parallélisébasé sur la stratégie inspecteur-exécuteur pour les prochaines exécutions du programme.L’inspecteur implique une version allégée du programme récursif d’origine dont le rôle estde collecter, générer et vérifier les informations d’exécution qui sont essentielles pour garantir l’exactitude du code itératif affine équivalent. L’exécuteur est composé des bouclesaffines qui peuvent être parallélisées voire optimisées à l’aide du modèle polyédrique

Réécriture spéculative de srogrammes récursifs en boucles candidates à une parallélisation et une optimisation efficaces utilisant un mécanisme inspecteur-exécuteur.

In this thesis, we introduce Rec2Poly, a framework for speculative rewriting of recursive programs as affine loops that are candidates for efficient optimization and parallelization. Rec2Poly seeks a polyhedral-compliant run-time control and memory behavior in recursions making use of an offline profiling technique. When it succeeds to model the behavior of a recursive program as affine loops, it can use the affine loop model to automatically generate an optimized and parallelized code based on the inspector-executor strategy for the next executions of the program. The inspector involves a light version of the original recursive program whose role is to collect, generate and verify run-time information that is crucial to ensure the correctness of the equivalent affine iterative code. The executor is composed of the affine loops that can be parallelized or even optimized using the polyhedral model.Dans cette thèse, nous proposons Rec2Poly, un cadriciel pour la réécriture spéculative des programmes récursifs sous forme de boucles affines qui sont candidates à une parallélisation et une optimisation efficaces. Rec2Poly cherche un flot de contrôle dynamique et un comportement mémoire conformes au modèle polyédrique dans les récursions, en utilisant une technique de profilage hors ligne. Lorsqu’il réussit à modéliser le comportement d’un programme récursif sous forme de boucles affines, il peut utiliser le modèle de boucle affine pour générer automatiquement un code optimisé et parallélisé basé sur la stratégie inspecteur-exécuteur pour les prochaines exécutions du programme. L’inspecteur implique une version allégée du programme récursif d’origine dont le rôle est de collecter, générer et vérifier les informations d’exécution qui sont essentielles pour garantir l’exactitude du code itératif affine équivalent. L’exécuteur est composé des boucles affines qui peuvent être parallélisées voire optimisées à l’aide du modèle polyédrique